home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / modula2 / hk_lib / def_mod / converts.def < prev    next >
Encoding:
Modula Definition  |  1994-09-22  |  18.1 KB  |  300 lines
  1. DEFINITION MODULE  ConvertStr;
  2.  
  3. (*****************************************************************************)
  4. (* Dieses Modul enthaelt Prozeduren zur Wandlung der Standarddatentypen in   *)
  5. (* und aus Strings. Neben den auf einen Datentyp festgelegten gibt es noch   *)
  6. (* Universalprozeduren, die fuer die Umwandlung beliebiger Datentypen der    *)
  7. (* entsprechenden Laenge gedacht sind; Hier kann auch die Zahlenbasis angege-*)
  8. (* ben werden, sodass zum Beispiel auch BITSETs ausgegeben werden koennen    *)
  9. (* ( mit "NumToStr", "StrToNum" und basis = "bin", allerdings ohne fuehrende *)
  10. (* Nullen ).                                                                 *)
  11. (*                                                                           *)
  12. (* Jede Prozedur gibt im Parameter <done> zurueck, ob die Umwandlung ohne    *)
  13. (* Fehler verlaufen ist; moegliche Fehler sind:                              *)
  14. (*                                                                           *)
  15. (*  - Bei der Umwandlung in Strings:                                         *)
  16. (*                Der String ist zu kurz                                     *)
  17. (*                                                                           *)
  18. (*  - Bei der Umwandlung aus Strings:                                        *)
  19. (*                Der String enthaelt ein ungueltiges Zeichen,               *)
  20. (*                Wertebereich des Typs wuerde ueberschritten                *)
  21. (*                nicht genuegend Stellen angegeben ( bei "StrToBitset" )    *)
  22. (*                                                                           *)
  23. (* Falls erforderlich, kann die 'genaue' Fehlerursache danach mit            *)
  24. (* "LastResult" ermittelt werden. Es kann auch eine automatische Fehlermel-  *)
  25. (* dung erfolgen, falls mit "AssignConvHandler" eine entsprechende Prozedur  *)
  26. (* definiert wurde.                                                          *)
  27. (*                                                                           *)
  28. (* Bei der Wandlung aus Strings werden fuehrende Leerzeichen ignoriert;      *)
  29. (* fuehrende Nullen sind erlaubt. Die Wertangabe darf nur aus Zeichen beste- *)
  30. (* hen, die fuer den jeweiligen Typ erlaubt sind, und hinter dem letzten     *)
  31. (* gueltigen Zeichen muss entweder der String beendet sein, oder es muss ein *)
  32. (* Begrenzungszeichen ( <= 7FH, nicht alphanumerisch ) folgen.               *)
  33. (* Steht hinter dem letzten gueltigen Zeichen trotzdem noch etwas, so ist    *)
  34. (* zwar <done> = FALSE, aber in <wert> wird der bis zu diesem ersten un-     *)
  35. (* gueltigen Zeichen konvertierte Wert zurueckgeliefert. Sonst wird im Falle *)
  36. (* von done = FALSE in <wert> Null zurueckgeliefert.                         *)
  37. (*                                                                           *)
  38. (* Bei der Wandlung in Strings wird  das Ergebnis rechtsbuendig mit der      *)
  39. (* angegebenen Feldweite geschrieben; passt das Ergebnis nicht in die angege-*)
  40. (* bene Feldbreite, werden soviele Zeichen belegt wie fuer die Darstellung   *)
  41. (* noetig sind.                                                              *)
  42. (* Ist <feld> gleich Null oder eins, ist der Ergebnisstring so kurz wie      *)
  43. (* moeglich - es gibt keine fuehrenden Leerzeichen.                          *)
  44. (*___________________________________________________________________________*)
  45. (*  12-Feb-90 , Holger Kleinschmidt                                          *)
  46. (*****************************************************************************)
  47.  
  48. FROM  SYSTEM  IMPORT  (* TYPE *)  BYTE, WORD;
  49.  
  50. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  51.  
  52.   TYPE  Base = ( bin,        (* '0'..'1'                   *)
  53.                  oct,        (* '0'..'7'                   *)
  54.                  dec,        (* '0'..'9'                   *)
  55.                  hex );      (* '0'..'9','a'..'f','A'..'F' *)
  56.  
  57.         ConvertResult = ( converted, strToShort, invalidDigit, overflow );
  58.  
  59.         ConvHandler   = PROCEDURE ((* EIN/ -- procname *) ARRAY OF CHAR,
  60.                                    (* EIN/ -- convres  *) ConvertResult  );
  61.  
  62. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  63.  
  64.   PROCEDURE  AssignConvHandler ((* EIN/ -- *) handler : ConvHandler );
  65.  
  66.   PROCEDURE  UnAssignConvHandler;
  67.  
  68.  (*-------------------------------------------------------------------------
  69.   | Ist mit "AssignConvHandler" eine Fehlerbehandlungsroutine definiert wor-|
  70.   | den, so wird diese jedesmal automatisch aufgerufen, wenn bei einer Kon- |
  71.   | vertierung ein Fehler aufgetreten ist; die Prozedur erhaelt als Parame- |
  72.   | ter den Fehler vom Typ "ConvertResult" und den Namen der Prozedur, in   |
  73.   | der der Fehler auftrat.                                                 |
  74.   | Nach Programmstart oder Aufruf von "UnAssignConvHandler" wird vom Modul |
  75.   | kein Handler beim Auftritt eines Fehlers aktiviert.                     |
  76.   |                                                                         |
  77.   | Die automatische Fehlermeldung ist besonders in der Testphase zu emp-   |
  78.   | fehlen, eine einfache Routine koennte z.B. so aussehen:                 |
  79.   |                                                                         |
  80.   |   PROCEDURE Convhandler( proc : ARRAY OF CHAR; fehler : ConvertResult );|
  81.   |     BEGIN                                                               |
  82.   |       WriteLn;                                                          |
  83.   |       WriteString('Fehler bei Zahlkonvertierung - ');                   |
  84.   |       WriteString('Prozedur '); WriteString(proc); Write(':');          |
  85.   |       WriteLn;                                                          |
  86.   |       CASE  fehler  OF                                                  |
  87.   |          converted : WriteString('Alles ok');                           |
  88.   |        | strToShort :                                                   |
  89.   |            WriteString('Die Zahldarstellung passt nicht in den String');|
  90.   |        | invalidDigit :                                                 |
  91.   |            WriteString('In dem String ist ein fuer den zu wandelnden'); |
  92.   |            WriteLn;                                                     |
  93.   |            WriteString('Wert ungueltiges Zeichen aufgetreten');         |
  94.   |        | overflow:                                                      |
  95.   |            WriteString('Der Wertebereich des zu wandelnden Typs wurde');|
  96.   |            WriteString(' ueberschritten');                              |
  97.   |        ELSE                                                             |
  98.   |            WriteString('Totaler Zusammenbruch...');                     |
  99.   |       END; (* CASE *)                                                   |
  100.   |       WriteLn;                                                          |
  101.   |       IF  ( NextIndex() > HIGH( str ))  OR                              |
  102.   |           ( str[NextIndex()] = 0C    )                                  |
  103.   |       THEN                                                              |
  104.   |         WriteString('Stringende aufgetreten');                          |
  105.   |       ELSE                                                              |
  106.   |         WriteString('Das fehlerhafte Zeichen ist: ');                   |
  107.   |         Write("'"); Write(str[NextIndex()]); Write("'");                |
  108.   |         WriteString('  Index: '); WriteCard(NextIndex(),0);             |
  109.   |       END;                                                              |
  110.   |       WriteLn; WriteLn;                                                 |
  111.   |     END  Convhandler;                                                   |
  112.    -------------------------------------------------------------------------*)
  113.  
  114.  
  115.  
  116.   PROCEDURE  LastConvResult ( ): ConvertResult;
  117.  
  118.  (*-------------------------------------------------------------------------
  119.   | Liefert das Resultat der letzten Konvertierung, falls <done> nicht aus- |
  120.   | reichen sollte. Moegliche Kombinationen sind:                           |
  121.   |                                                                         |
  122.   |   - converted   : letzte Operation war ok., <done> war = TRUE           |
  123.   |   - strToShort  : moegliches Resultat aller Prozeduren, die Werte in    |
  124.   |                   Strings wandeln: Der Laenge des Strings reicht nicht  |
  125.   |                   fuer die Darstellung des Wertes.                      |
  126.   |   - invalidDigit: moegliches Resultat aller Prozeduren, die Strings in  |
  127.   |                   Werte wandeln: im String ist ein Zeichen aufgetreten, |
  128.   |                   das keine gueltige Ziffer fuer den zu wandelnden Typ  |
  129.   |                   darstellt, oder der String enthaelt ueberhaupt keine  |
  130.   |                   druckbaren Zeichen; bei "StrToBitset" auch, wenn      |
  131.   |                   weniger oder mehr als 16 Bits angegeben sind.         |
  132.   |   - overflow    : moegliches Resultat aller Prozeduren, die Strings in  |
  133.   |                   Werte wandeln, ausser "StrToBool" und "StrToBitset":  |
  134.   |                   Die im String angegebene Zahlendarstellung ist zu     |
  135.   |                   gross fuer den zu wandelnden Typ.                     |
  136.    -------------------------------------------------------------------------*)
  137.  
  138.  
  139.   PROCEDURE  NextIndex ( ): INTEGER;
  140.  
  141.  (*-------------------------------------------------------------------------
  142.   | Hiermit kann nach einer Konvertierung der Index des Zeichens im String  |
  143.   | ernittelt werden, das hinter dem letzten fuer die Konvertierung benutz- |
  144.   | ten steht. Trat bei der Konvertierung ein Fehler auf, so ist das der    |
  145.   | Index des fehlerhaften Zeichens.                                        |
  146.    -------------------------------------------------------------------------*)
  147.  
  148. (*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*)
  149.  
  150.  
  151.   PROCEDURE  BoolToStr ((* EIN/ -- *)     wert : BOOLEAN;
  152.                         (* EIN/ -- *)     feld : CARDINAL;
  153.                         (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  154.                         (* -- /AUS *) VAR done : BOOLEAN       );
  155.  
  156.   PROCEDURE  StrToBool ((* EIN/ -- *)     str  : ARRAY OF CHAR;
  157.                         (* -- /AUS *) VAR wert : BOOLEAN;
  158.                         (* -- /AUS *) VAR done : BOOLEAN       );
  159.  
  160.  (*-------------------------------------------------------------------------
  161.   | Aus- und Eingabe boolscher Werte. "BoolToStr" liefert je nach <wert>    |
  162.   | in <str> den <feld> Zeichen breiten rechtsbuendigen Text 'TRUE' oder    |
  163.   | 'FALSE'.                                                                |
  164.   | "StrToBool" akzeptiert als Eingaben: 'TRUE' und 'T' fuer <wert> = TRUE  |
  165.   | bzw. 'FALSE' und 'F' fuer <wert> = FALSE.                               |
  166.   | Es sind auch Kleinbuchstaben erlaubt.                                   |
  167.    -------------------------------------------------------------------------*)
  168.  
  169.  
  170.   PROCEDURE  BitsetToStr ((* EIN/ -- *)     menge: BITSET;
  171.                           (* EIN/ -- *)     feld : CARDINAL;
  172.                           (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  173.                           (* -- /AUS *) VAR done : BOOLEAN       );
  174.  
  175.   PROCEDURE  StrToBitset ((* EIN/ -- *)     str  : ARRAY OF CHAR;
  176.                           (* -- /AUS *) VAR menge: BITSET;
  177.                           (* -- /AUS *) VAR done : BOOLEAN       );
  178.  
  179.  (*-------------------------------------------------------------------------
  180.   | Konvertierung von BITSETs. Im Gegensatz zur Konvertierung mit "NumToStr"|
  181.   | werden immer 16 Stellen ausgegeben und verlangt, also auch fuehrende    |
  182.   | Nullen; '0' steht fuer ein nicht vorhandenes Element,'1' steht fuer ein |
  183.   | vorhandenes. Die Numerierung der Bits ist von rechts nach links, also   |
  184.   | so, wie sie auf Maschinenebene ist.                                     |
  185.    -------------------------------------------------------------------------*)
  186.  
  187.  
  188.   PROCEDURE  CardToStr     ((* EIN/ -- *)     wert : CARDINAL;
  189.                             (* EIN/ -- *)     feld : CARDINAL;
  190.                             (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  191.                             (* -- /AUS *) VAR done : BOOLEAN       );
  192.  
  193.   PROCEDURE  LongCardToStr ((* EIN/ -- *)     wert : LONGCARD;
  194.                             (* EIN/ -- *)     feld : CARDINAL;
  195.                             (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  196.                             (* -- /AUS *) VAR done : BOOLEAN       );
  197.  
  198.  
  199.   PROCEDURE  StrToCard     ((* EIN/ -- *)     str  : ARRAY OF CHAR;
  200.                             (* -- /AUS *) VAR wert : CARDINAL;
  201.                             (* -- /AUS *) VAR done : BOOLEAN       );
  202.  
  203.   PROCEDURE  StrToLongCard ((* EIN/ -- *)     str  : ARRAY OF CHAR;
  204.                             (* -- /AUS *) VAR wert : LONGCARD;
  205.                             (* -- /AUS *) VAR done : BOOLEAN       );
  206.  
  207.  (*-------------------------------------------------------------------------
  208.   | Kardinalzahlen werden dezimal interpretiert, deshalb sind nur die       |
  209.   | Ziffern von '0' bis '9' gueltige Zeichen; direkt vor der Zahl darf ein  |
  210.   | '+' stehen, hinter der Zahl darf kein 'H','B' oder 'C' als Zahlenbasis- |
  211.   | angabe stehen. Bei der Ausgabe wird kein Vorzeichen geschrieben.        |
  212.   |                                                                         |
  213.   |            ['+']digit{digit}(IsDelimiter|Stringende)                    |
  214.    -------------------------------------------------------------------------*)
  215.  
  216.  
  217.  
  218.   PROCEDURE  IntToStr     ((* EIN/ -- *)     wert : INTEGER;
  219.                            (* EIN/ -- *)     feld : CARDINAL;
  220.                            (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  221.                            (* -- /AUS *) VAR done : BOOLEAN       );
  222.  
  223.   PROCEDURE  LongIntToStr ((* EIN/ -- *)     wert : LONGINT;
  224.                            (* EIN/ -- *)     feld : CARDINAL;
  225.                            (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  226.                            (* -- /AUS *) VAR done : BOOLEAN       );
  227.  
  228.  
  229.   PROCEDURE  StrToInt     ((* EIN/ -- *)     str  : ARRAY OF CHAR;
  230.                            (* -- /AUS *) VAR wert : INTEGER;
  231.                            (* -- /AUS *) VAR done : BOOLEAN       );
  232.  
  233.   PROCEDURE  StrToLongInt ((* EIN/ -- *)     str  : ARRAY OF CHAR;
  234.                            (* -- /AUS *) VAR wert : LONGINT;
  235.                            (* -- /AUS *) VAR done : BOOLEAN       );
  236.  
  237.  (*-------------------------------------------------------------------------
  238.   | Bei "StrToInt" und "StrToLongInt" darf das erste Nicht-Leerzeichen ein  |
  239.   | '-' oder '+' sein, hinter dem unmittelbar Ziffern zwischen '0' und '9'  |
  240.   | folgen.                                                                 |
  241.   | Bei "IntToStr" und "LongIntToStr" wird fuer das Vorzeichen immer ein    |
  242.   | zusaetzliches Zeichen benoetigt; wenn <wert> positiv ist, steht vor der |
  243.   | Zahl ein Leerzeichen.                                                   |
  244.   |                                                                         |
  245.   |            ['+'|'-']digit{digit}(IsDelimiter|Stringende)                |
  246.    -------------------------------------------------------------------------*)
  247.  
  248.  
  249.   PROCEDURE  ShortNumToStr ((* EIN/ -- *)     wert : BYTE;
  250.                             (* EIN/ -- *)     basis: Base;
  251.                             (* EIN/ -- *)     feld : CARDINAL;
  252.                             (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  253.                             (* -- /AUS *) VAR done : BOOLEAN       );
  254.  
  255.   PROCEDURE  NumToStr      ((* EIN/ -- *)     wert : WORD;
  256.                             (* EIN/ -- *)     basis: Base;
  257.                             (* EIN/ -- *)     feld : CARDINAL;
  258.                             (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  259.                             (* -- /AUS *) VAR done : BOOLEAN       );
  260.  
  261.   PROCEDURE  LongNumToStr  ((* EIN/ -- *)     wert : LONGCARD;
  262.                             (* EIN/ -- *)     basis: Base;
  263.                             (* EIN/ -- *)     feld : CARDINAL;
  264.                             (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  265.                             (* -- /AUS *) VAR done : BOOLEAN       );
  266.  
  267.  
  268.   PROCEDURE  StrToShortNum ((* EIN/ -- *)     str  : ARRAY OF CHAR;
  269.                             (* EIN/ -- *)     basis: Base;
  270.                             (* -- /AUS *) VAR wert : BYTE;
  271.                             (* -- /AUS *) VAR done : BOOLEAN       );
  272.  
  273.   PROCEDURE  StrToNum      ((* EIN/ -- *)     str  : ARRAY OF CHAR;
  274.                             (* EIN/ -- *)     basis: Base;
  275.                             (* -- /AUS *) VAR wert : WORD;
  276.                             (* -- /AUS *) VAR done : BOOLEAN       );
  277.  
  278.   PROCEDURE  StrToLongNum  ((* EIN/ -- *)     str  : ARRAY OF CHAR;
  279.                             (* EIN/ -- *)     basis: Base;
  280.                             (* -- /AUS *) VAR wert : LONGCARD;
  281.                             (* -- /AUS *) VAR done : BOOLEAN       );
  282.  
  283.  (*-------------------------------------------------------------------------
  284.   | Die Prozeduren wandeln einen beliebigen Wert der angegebenen Laenge in  |
  285.   | einen String bzw. umgekehrt; die gewuenschte Zahlenbasis kann angegeben |
  286.   | werden.                                                                 |
  287.   | <wert> wird immer ohne Vorzeichen betrachtet.                           |
  288.   | Bei "StrToNum", "StrToLongNum" und "StrToShortNum" darf die Zahlenbasis |
  289.   | nicht als letztes Zeichen hinter dem Wert stehen, dies gibt entweder    |
  290.   | einen Fehler, oder wenn die Zahlenbasis "hex" = 16 ist, werden die An-  |
  291.   | gaben 'C' und 'B' als zur Zahl gehoerig betrachtet, da sie gueltige Zif-|
  292.   | fern zu dieser Zahlenbasis darstellen!                                  |
  293.   |                                                                         |
  294.   |            ['+']digit{digit}(IsDelimiter|Stringende)                    |
  295.   |                                                                         |
  296.   | 'digit' entsprechend der Zahlenbasis.                                   |
  297.    -------------------------------------------------------------------------*)
  298.  
  299. END  ConvertStr.
  300.